package com.ourteam.product.requirement.dao;

import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;

import org.apache.commons.lang.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;


/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2018-05-03 16:45:30
  * Warning ! This file will be overwrite when regenerate !
  *
 */
public class ProductRequirementFeatureRelateDAOQueryBean extends BaseQueryBean {
    public ProductRequirementFeatureRelateDAOQueryBean() {
        super();
    }

    public ProductRequirementFeatureRelateDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }

    public ProductRequirementFeatureRelateDAOQueryBean(
        BaseQueryBean aQueryBean, Map tableReplaceMap) {
        super(aQueryBean, tableReplaceMap);
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();

        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }

        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        return new Criteria(this);
    }

    public void addIdSelectProperty() {
        addIdSelectProperty("id");
    }

    public void addIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.Id, aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.Id, "id");
        }
    }

    public void addProductRequirementIdSelectProperty() {
        addProductRequirementIdSelectProperty("productRequirementId");
    }

    public void addProductRequirementIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementId,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementId,
                "productRequirementId");
        }
    }

    public void addProductFeatureIdSelectProperty() {
        addProductFeatureIdSelectProperty("productFeatureId");
    }

    public void addProductFeatureIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureId,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureId,
                "productFeatureId");
        }
    }

    public void addStatusSelectProperty() {
        addStatusSelectProperty("status");
    }

    public void addStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.Status, aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.Status,
                "status");
        }
    }

    public void addRemarksSelectProperty() {
        addRemarksSelectProperty("remarks");
    }

    public void addRemarksSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.Remarks,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.Remarks,
                "remarks");
        }
    }

    public void addProductRequirementVersionIdSelectProperty() {
        addProductRequirementVersionIdSelectProperty(
            "productRequirementVersionId");
    }

    public void addProductRequirementVersionIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId,
                "productRequirementVersionId");
        }
    }

    public void addProductFeatureVersionIdSelectProperty() {
        addProductFeatureVersionIdSelectProperty("productFeatureVersionId");
    }

    public void addProductFeatureVersionIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId,
                "productFeatureVersionId");
        }
    }

    public void addProductRequirementVersionSelectProperty() {
        addProductRequirementVersionSelectProperty("productRequirementVersion");
    }

    public void addProductRequirementVersionSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementVersion,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementVersion,
                "productRequirementVersion");
        }
    }

    public void addProductRequirementVersionTypeSelectProperty() {
        addProductRequirementVersionTypeSelectProperty(
            "productRequirementVersionType");
    }

    public void addProductRequirementVersionTypeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType,
                "productRequirementVersionType");
        }
    }

    public void addProductRequirementVersionStatusSelectProperty() {
        addProductRequirementVersionStatusSelectProperty(
            "productRequirementVersionStatus");
    }

    public void addProductRequirementVersionStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus,
                "productRequirementVersionStatus");
        }
    }

    public void addProductFeatureVersionSelectProperty() {
        addProductFeatureVersionSelectProperty("productFeatureVersion");
    }

    public void addProductFeatureVersionSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureVersion,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureVersion,
                "productFeatureVersion");
        }
    }

    public void addProductFeatureVersionTypeSelectProperty() {
        addProductFeatureVersionTypeSelectProperty("productFeatureVersionType");
    }

    public void addProductFeatureVersionTypeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType,
                "productFeatureVersionType");
        }
    }

    public void addProductFeatureVersionStatusSelectProperty() {
        addProductFeatureVersionStatusSelectProperty(
            "productFeatureVersionStatus");
    }

    public void addProductFeatureVersionStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus,
                "productFeatureVersionStatus");
        }
    }

    public void addProductRequirementCodeSelectProperty() {
        addProductRequirementCodeSelectProperty("productRequirementCode");
    }

    public void addProductRequirementCodeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementCode,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementCode,
                "productRequirementCode");
        }
    }

    public void addProductRequirementNameSelectProperty() {
        addProductRequirementNameSelectProperty("productRequirementName");
    }

    public void addProductRequirementNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementName,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementName,
                "productRequirementName");
        }
    }

    public void addProductRequirementContentSelectProperty() {
        addProductRequirementContentSelectProperty("productRequirementContent");
    }

    public void addProductRequirementContentSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementContent,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementContent,
                "productRequirementContent");
        }
    }

    public void addProductRequirementTypeSelectProperty() {
        addProductRequirementTypeSelectProperty("productRequirementType");
    }

    public void addProductRequirementTypeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementType,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementType,
                "productRequirementType");
        }
    }

    public void addProductRequirementLevelSelectProperty() {
        addProductRequirementLevelSelectProperty("productRequirementLevel");
    }

    public void addProductRequirementLevelSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementLevel,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementLevel,
                "productRequirementLevel");
        }
    }

    public void addProductRequirementKindSelectProperty() {
        addProductRequirementKindSelectProperty("productRequirementKind");
    }

    public void addProductRequirementKindSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementKind,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementKind,
                "productRequirementKind");
        }
    }

    public void addProductRequirementSourceSelectProperty() {
        addProductRequirementSourceSelectProperty("productRequirementSource");
    }

    public void addProductRequirementSourceSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementSource,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductRequirementSource,
                "productRequirementSource");
        }
    }

    public void addProductFeatureCodeSelectProperty() {
        addProductFeatureCodeSelectProperty("productFeatureCode");
    }

    public void addProductFeatureCodeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureCode,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureCode,
                "productFeatureCode");
        }
    }

    public void addProductFeatureNameSelectProperty() {
        addProductFeatureNameSelectProperty("productFeatureName");
    }

    public void addProductFeatureNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureName,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureName,
                "productFeatureName");
        }
    }

    public void addProductFeatureCanTestSelectProperty() {
        addProductFeatureCanTestSelectProperty("productFeatureCanTest");
    }

    public void addProductFeatureCanTestSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest,
                "productFeatureCanTest");
        }
    }

    public void addProductFeatureIsKeyFeatureSelectProperty() {
        addProductFeatureIsKeyFeatureSelectProperty(
            "productFeatureIsKeyFeature");
    }

    public void addProductFeatureIsKeyFeatureSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature,
                aAlias);
        } else {
            addSelectProperty(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature,
                "productFeatureIsKeyFeature");
        }
    }

    public void addAllSelectProperties() {
        addIdSelectProperty();

        addProductRequirementIdSelectProperty();

        addProductFeatureIdSelectProperty();

        addStatusSelectProperty();

        addRemarksSelectProperty();

        addProductRequirementVersionIdSelectProperty();

        addProductFeatureVersionIdSelectProperty();

        addProductRequirementVersionSelectProperty();

        addProductRequirementVersionTypeSelectProperty();

        addProductRequirementVersionStatusSelectProperty();

        addProductFeatureVersionSelectProperty();

        addProductFeatureVersionTypeSelectProperty();

        addProductFeatureVersionStatusSelectProperty();

        addProductRequirementCodeSelectProperty();

        addProductRequirementNameSelectProperty();

        addProductRequirementContentSelectProperty();

        addProductRequirementTypeSelectProperty();

        addProductRequirementLevelSelectProperty();

        addProductRequirementKindSelectProperty();

        addProductRequirementSourceSelectProperty();

        addProductFeatureCodeSelectProperty();

        addProductFeatureNameSelectProperty();

        addProductFeatureCanTestSelectProperty();

        addProductFeatureIsKeyFeatureSelectProperty();
    }

    public static class Criteria extends BaseWhereCriterion<ProductRequirementFeatureRelateDAOQueryBean> {
        protected Criteria(
            ProductRequirementFeatureRelateDAOQueryBean aParentObject) {
            super(aParentObject);
        }

        public Criteria andIdIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " is null");

            return this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.Id +
                " is not null");

            return this;
        }

        public Criteria andIdIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.Id +
                " is not null AND " + IProductRequirementFeatureRelateDAO.Id +
                " <> ''");

            return this;
        }

        public Criteria andIdIsEmpty() {
            addCriterion("(" + IProductRequirementFeatureRelateDAO.Id +
                " is null OR " + IProductRequirementFeatureRelateDAO.Id +
                " = '')");

            return this;
        }

        public Criteria andIdEqualTo(long value) {
            return andIdEqualTo(Long.valueOf(value));
        }

        public Criteria andIdEqualTo(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " = ", value,
                "id");

            return this;
        }

        public Criteria andIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Id);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotEqualTo(long value) {
            return andIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " <>", value,
                "id");

            return this;
        }

        public Criteria andIdNotEqualToOrIsNull(long value) {
            return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id +
                " is null OR " + IProductRequirementFeatureRelateDAO.Id +
                " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Id);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThan(long value) {
            return andIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " >", value,
                "id");

            return this;
        }

        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Id);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " >=", value,
                "id");

            return this;
        }

        public Criteria andIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Id);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThan(long value) {
            return andIdLessThan(Long.valueOf(value));
        }

        public Criteria andIdLessThan(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " <", value,
                "id");

            return this;
        }

        public Criteria andIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Id);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            return andIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " <=", value,
                "id");

            return this;
        }

        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Id);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdIn(long[] values) {
            if (values.length == 1) {
                return andIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Id + " in",
                    values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Id +
                    " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Id + " in",
                    values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Id +
                    " not in", values, "id");

                return this;
            }
        }

        public Criteria andIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Id + " in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Id +
                    " not in", Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " between",
                value1, value2, "id");

            return this;
        }

        public Criteria andIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id + " between",
                value1, value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id +
                " not between", value1, value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.Id +
                " not between", value1, value2, "id");

            return this;
        }

        public Criteria andProductRequirementIdIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " is null");

            return this;
        }

        public Criteria andProductRequirementIdIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementIdIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementIdIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementIdEqualTo(long value) {
            return andProductRequirementIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductRequirementIdEqualTo(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " = ", value, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementIdEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementIdNotEqualTo(long value) {
            return andProductRequirementIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductRequirementIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " <>", value, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdNotEqualToOrIsNull(long value) {
            return andProductRequirementIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductRequirementIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " <>", value, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementIdGreaterThan(long value) {
            return andProductRequirementIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductRequirementIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " >", value, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementIdGreaterThanOrEqualTo(long value) {
            return andProductRequirementIdGreaterThanOrEqualTo(Long.valueOf(
                    value));
        }

        public Criteria andProductRequirementIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " >=", value, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementIdLessThan(long value) {
            return andProductRequirementIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductRequirementIdLessThan(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " <", value, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementIdLessThanOrEqualTo(long value) {
            return andProductRequirementIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductRequirementIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " <=", value, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementIdIn(long[] values) {
            if (values.length == 1) {
                return andProductRequirementIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                    " in", values, "productRequirementId");

                return this;
            }
        }

        public Criteria andProductRequirementIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductRequirementIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                    " not in", values, "productRequirementId");

                return this;
            }
        }

        public Criteria andProductRequirementIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductRequirementIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                    " in", values, "productRequirementId");

                return this;
            }
        }

        public Criteria andProductRequirementIdNotIn(
            List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductRequirementIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                    " not in", values, "productRequirementId");

                return this;
            }
        }

        public Criteria andProductRequirementIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductRequirementIdEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                    " in", Arrays.asList(values), "productRequirementId");

                return this;
            }
        }

        public Criteria andProductRequirementIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductRequirementIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                    " not in", Arrays.asList(values), "productRequirementId");

                return this;
            }
        }

        public Criteria andProductRequirementIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementIdNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementIdBetween(long value1, long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " between", value1, value2, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " between", value1, value2, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdNotBetween(long value1,
            long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " not between", value1, value2, "productRequirementId");

            return this;
        }

        public Criteria andProductRequirementIdNotBetween(
            java.lang.Long value1, java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementId +
                " not between", value1, value2, "productRequirementId");

            return this;
        }

        public Criteria andProductFeatureIdIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " is null");

            return this;
        }

        public Criteria andProductFeatureIdIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " is not null");

            return this;
        }

        public Criteria andProductFeatureIdIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " <> ''");

            return this;
        }

        public Criteria andProductFeatureIdIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " = '')");

            return this;
        }

        public Criteria andProductFeatureIdEqualTo(long value) {
            return andProductFeatureIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductFeatureIdEqualTo(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " = ", value, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIdNotEqualTo(long value) {
            return andProductFeatureIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductFeatureIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " <>", value, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdNotEqualToOrIsNull(long value) {
            return andProductFeatureIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductFeatureIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureId + " <>",
                value, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIdGreaterThan(long value) {
            return andProductFeatureIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductFeatureIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " >", value, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIdGreaterThanOrEqualTo(long value) {
            return andProductFeatureIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductFeatureIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " >=", value, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIdLessThan(long value) {
            return andProductFeatureIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductFeatureIdLessThan(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " <", value, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIdLessThanOrEqualTo(long value) {
            return andProductFeatureIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductFeatureIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " <=", value, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIdIn(long[] values) {
            if (values.length == 1) {
                return andProductFeatureIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                    " in", values, "productFeatureId");

                return this;
            }
        }

        public Criteria andProductFeatureIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductFeatureIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                    " not in", values, "productFeatureId");

                return this;
            }
        }

        public Criteria andProductFeatureIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductFeatureIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                    " in", values, "productFeatureId");

                return this;
            }
        }

        public Criteria andProductFeatureIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductFeatureIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                    " not in", values, "productFeatureId");

                return this;
            }
        }

        public Criteria andProductFeatureIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductFeatureIdEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                    " in", Arrays.asList(values), "productFeatureId");

                return this;
            }
        }

        public Criteria andProductFeatureIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductFeatureIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                    " not in", Arrays.asList(values), "productFeatureId");

                return this;
            }
        }

        public Criteria andProductFeatureIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIdBetween(long value1, long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " between", value1, value2, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " between", value1, value2, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdNotBetween(long value1, long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " not between", value1, value2, "productFeatureId");

            return this;
        }

        public Criteria andProductFeatureIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureId +
                " not between", value1, value2, "productFeatureId");

            return this;
        }

        public Criteria andStatusIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.Status +
                " is null");

            return this;
        }

        public Criteria andStatusIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.Status +
                " is not null");

            return this;
        }

        public Criteria andStatusIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.Status +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.Status + " <> ''");

            return this;
        }

        public Criteria andStatusIsEmpty() {
            addCriterion("(" + IProductRequirementFeatureRelateDAO.Status +
                " is null OR " + IProductRequirementFeatureRelateDAO.Status +
                " = '')");

            return this;
        }

        public Criteria andStatusEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " = ",
                value, "status");

            return this;
        }

        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Status);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " <>",
                value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToOrIsNull(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status +
                " is null OR " + IProductRequirementFeatureRelateDAO.Status +
                " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Status);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " >",
                value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Status);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " >=",
                value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Status);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " <",
                value, "status");

            return this;
        }

        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Status);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " <=",
                value, "status");

            return this;
        }

        public Criteria andStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Status);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.Status +
                " not like", buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Status +
                    " in", values, "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Status +
                    " not in", values, "status");

                return this;
            }
        }

        public Criteria andStatusIn(String[] values) {
            if (values.length == 1) {
                return andStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Status +
                    " in", Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Status +
                    " not in", Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status +
                " between", value1, value2, "status");

            return this;
        }

        public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.Status +
                " not between", value1, value2, "status");

            return this;
        }

        public Criteria andRemarksIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                " is null");

            return this;
        }

        public Criteria andRemarksIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                " is not null");

            return this;
        }

        public Criteria andRemarksIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.Remarks + " <> ''");

            return this;
        }

        public Criteria andRemarksIsEmpty() {
            addCriterion("(" + IProductRequirementFeatureRelateDAO.Remarks +
                " is null OR " + IProductRequirementFeatureRelateDAO.Remarks +
                " = '')");

            return this;
        }

        public Criteria andRemarksEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " = ",
                value, "remarks");

            return this;
        }

        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Remarks);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " <>",
                value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToOrIsNull(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                " is null OR " + IProductRequirementFeatureRelateDAO.Remarks +
                " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Remarks);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " >",
                value, "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Remarks);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " >=",
                value, "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Remarks);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " <",
                value, "remarks");

            return this;
        }

        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Remarks);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " <=",
                value, "remarks");

            return this;
        }

        public Criteria andRemarksLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.Remarks);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                " not like", buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                    " in", values, "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                    " not in", values, "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(String[] values) {
            if (values.length == 1) {
                return andRemarksEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                    " in", Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(String[] values) {
            if (values.length == 1) {
                return andRemarksNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                    " not in", Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                " between", value1, value2, "remarks");

            return this;
        }

        public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.Remarks +
                " not between", value1, value2, "remarks");

            return this;
        }

        public Criteria andProductRequirementVersionIdIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " is null");

            return this;
        }

        public Criteria andProductRequirementVersionIdIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementVersionIdIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementVersionIdIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementVersionIdEqualTo(long value) {
            return andProductRequirementVersionIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductRequirementVersionIdEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " = ", value, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionIdEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionIdNotEqualTo(long value) {
            return andProductRequirementVersionIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductRequirementVersionIdNotEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " <>", value, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdNotEqualToOrIsNull(
            long value) {
            return andProductRequirementVersionIdNotEqualToOrIsNull(Long.valueOf(
                    value));
        }

        public Criteria andProductRequirementVersionIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " <>", value, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionIdGreaterThan(long value) {
            return andProductRequirementVersionIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductRequirementVersionIdGreaterThan(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " >", value, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionIdGreaterThanOrEqualTo(
            long value) {
            return andProductRequirementVersionIdGreaterThanOrEqualTo(Long.valueOf(
                    value));
        }

        public Criteria andProductRequirementVersionIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " >=", value, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionIdLessThan(long value) {
            return andProductRequirementVersionIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductRequirementVersionIdLessThan(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " <", value, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionIdLessThanOrEqualTo(
            long value) {
            return andProductRequirementVersionIdLessThanOrEqualTo(Long.valueOf(
                    value));
        }

        public Criteria andProductRequirementVersionIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " <=", value, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionIdIn(long[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                    " in", values, "productRequirementVersionId");

                return this;
            }
        }

        public Criteria andProductRequirementVersionIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                    " not in", values, "productRequirementVersionId");

                return this;
            }
        }

        public Criteria andProductRequirementVersionIdIn(
            List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductRequirementVersionIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                    " in", values, "productRequirementVersionId");

                return this;
            }
        }

        public Criteria andProductRequirementVersionIdNotIn(
            List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductRequirementVersionIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                    " not in", values, "productRequirementVersionId");

                return this;
            }
        }

        public Criteria andProductRequirementVersionIdIn(
            java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionIdEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                    " in", Arrays.asList(values), "productRequirementVersionId");

                return this;
            }
        }

        public Criteria andProductRequirementVersionIdNotIn(
            java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                    " not in", Arrays.asList(values),
                    "productRequirementVersionId");

                return this;
            }
        }

        public Criteria andProductRequirementVersionIdIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionIdNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionIdBetween(long value1,
            long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " between", value1, value2, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdBetween(
            java.lang.Long value1, java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " between", value1, value2, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdNotBetween(long value1,
            long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " not between", value1, value2, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIdNotBetween(
            java.lang.Long value1, java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionId +
                " not between", value1, value2, "productRequirementVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " is null");

            return this;
        }

        public Criteria andProductFeatureVersionIdIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " is not null");

            return this;
        }

        public Criteria andProductFeatureVersionIdIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " <> ''");

            return this;
        }

        public Criteria andProductFeatureVersionIdIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " = '')");

            return this;
        }

        public Criteria andProductFeatureVersionIdEqualTo(long value) {
            return andProductFeatureVersionIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductFeatureVersionIdEqualTo(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " = ", value, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionIdEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionIdNotEqualTo(long value) {
            return andProductFeatureVersionIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductFeatureVersionIdNotEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " <>", value, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdNotEqualToOrIsNull(long value) {
            return andProductFeatureVersionIdNotEqualToOrIsNull(Long.valueOf(
                    value));
        }

        public Criteria andProductFeatureVersionIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " <>", value, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionIdGreaterThan(long value) {
            return andProductFeatureVersionIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductFeatureVersionIdGreaterThan(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " >", value, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionIdGreaterThanOrEqualTo(
            long value) {
            return andProductFeatureVersionIdGreaterThanOrEqualTo(Long.valueOf(
                    value));
        }

        public Criteria andProductFeatureVersionIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " >=", value, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionIdLessThan(long value) {
            return andProductFeatureVersionIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductFeatureVersionIdLessThan(java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " <", value, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionIdLessThanOrEqualTo(long value) {
            return andProductFeatureVersionIdLessThanOrEqualTo(Long.valueOf(
                    value));
        }

        public Criteria andProductFeatureVersionIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " <=", value, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionIdIn(long[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                    " in", values, "productFeatureVersionId");

                return this;
            }
        }

        public Criteria andProductFeatureVersionIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                    " not in", values, "productFeatureVersionId");

                return this;
            }
        }

        public Criteria andProductFeatureVersionIdIn(
            List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductFeatureVersionIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                    " in", values, "productFeatureVersionId");

                return this;
            }
        }

        public Criteria andProductFeatureVersionIdNotIn(
            List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductFeatureVersionIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                    " not in", values, "productFeatureVersionId");

                return this;
            }
        }

        public Criteria andProductFeatureVersionIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionIdEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                    " in", Arrays.asList(values), "productFeatureVersionId");

                return this;
            }
        }

        public Criteria andProductFeatureVersionIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                    " not in", Arrays.asList(values), "productFeatureVersionId");

                return this;
            }
        }

        public Criteria andProductFeatureVersionIdIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionIdNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionIdBetween(long value1,
            long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " between", value1, value2, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdBetween(
            java.lang.Long value1, java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " between", value1, value2, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdNotBetween(long value1,
            long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " not between", value1, value2, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductFeatureVersionIdNotBetween(
            java.lang.Long value1, java.lang.Long value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionId +
                " not between", value1, value2, "productFeatureVersionId");

            return this;
        }

        public Criteria andProductRequirementVersionIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " is null");

            return this;
        }

        public Criteria andProductRequirementVersionIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementVersionIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementVersionIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementVersionEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " = ", value, "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersion);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " <>", value, "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " <>", value, "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersion);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " >", value, "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersion);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " >=", value, "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersion);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " <", value, "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersion);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionLessThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " <=", value, "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersion);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " like", buffer.toString(), "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " not like", buffer.toString(), "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementVersionEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                    " in", values, "productRequirementVersion");

                return this;
            }
        }

        public Criteria andProductRequirementVersionNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementVersionNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                    " not in", values, "productRequirementVersion");

                return this;
            }
        }

        public Criteria andProductRequirementVersionIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                    " in", Arrays.asList(values), "productRequirementVersion");

                return this;
            }
        }

        public Criteria andProductRequirementVersionNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                    " not in", Arrays.asList(values),
                    "productRequirementVersion");

                return this;
            }
        }

        public Criteria andProductRequirementVersionIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " between", value1, value2, "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersion +
                " not between", value1, value2, "productRequirementVersion");

            return this;
        }

        public Criteria andProductRequirementVersionTypeIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " is null");

            return this;
        }

        public Criteria andProductRequirementVersionTypeIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementVersionTypeIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementVersionTypeIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementVersionTypeEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " = ", value, "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionTypeEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionTypeNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " <>", value, "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " <>", value, "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionTypeNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionTypeGreaterThan(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " >", value, "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionTypeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionTypeGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " >=", value, "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionTypeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionTypeLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " <", value, "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionTypeLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionTypeLessThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " <=", value, "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionTypeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionTypeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " like", buffer.toString(), "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " not like", buffer.toString(), "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementVersionTypeEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                    " in", values, "productRequirementVersionType");

                return this;
            }
        }

        public Criteria andProductRequirementVersionTypeNotIn(
            List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementVersionTypeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                    " not in", values, "productRequirementVersionType");

                return this;
            }
        }

        public Criteria andProductRequirementVersionTypeIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionTypeEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                    " in", Arrays.asList(values),
                    "productRequirementVersionType");

                return this;
            }
        }

        public Criteria andProductRequirementVersionTypeNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionTypeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                    " not in", Arrays.asList(values),
                    "productRequirementVersionType");

                return this;
            }
        }

        public Criteria andProductRequirementVersionTypeIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionTypeNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionTypeBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " between", value1, value2, "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionTypeNotBetween(
            String value1, String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionType +
                " not between", value1, value2, "productRequirementVersionType");

            return this;
        }

        public Criteria andProductRequirementVersionStatusIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " is null");

            return this;
        }

        public Criteria andProductRequirementVersionStatusIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementVersionStatusIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementVersionStatusIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementVersionStatusEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " = ", value, "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionStatusEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionStatusNotEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " <>", value, "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " <>", value, "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionStatusNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionStatusGreaterThan(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " >", value, "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionStatusGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionStatusGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " >=", value, "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionStatusLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " <", value, "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionStatusLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionStatusLessThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " <=", value, "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementVersionStatusLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " like", buffer.toString(), "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " not like", buffer.toString(),
                "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusIn(
            List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementVersionStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                    " in", values, "productRequirementVersionStatus");

                return this;
            }
        }

        public Criteria andProductRequirementVersionStatusNotIn(
            List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementVersionStatusNotEqualTo(values.get(
                        0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                    " not in", values, "productRequirementVersionStatus");

                return this;
            }
        }

        public Criteria andProductRequirementVersionStatusIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                    " in", Arrays.asList(values),
                    "productRequirementVersionStatus");

                return this;
            }
        }

        public Criteria andProductRequirementVersionStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementVersionStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                    " not in", Arrays.asList(values),
                    "productRequirementVersionStatus");

                return this;
            }
        }

        public Criteria andProductRequirementVersionStatusIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionStatusNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementVersionStatusBetween(
            String value1, String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " between", value1, value2, "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductRequirementVersionStatusNotBetween(
            String value1, String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementVersionStatus +
                " not between", value1, value2,
                "productRequirementVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " is null");

            return this;
        }

        public Criteria andProductFeatureVersionIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " is not null");

            return this;
        }

        public Criteria andProductFeatureVersionIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " <> ''");

            return this;
        }

        public Criteria andProductFeatureVersionIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " = '')");

            return this;
        }

        public Criteria andProductFeatureVersionEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " = ", value, "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersion);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " <>", value, "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionNotEqualToOrIsNull(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " <>", value, "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersion);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " >", value, "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersion);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " >=", value, "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersion);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " <", value, "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersion);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " <=", value, "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersion);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " like", buffer.toString(), "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " not like", buffer.toString(), "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureVersionEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                    " in", values, "productFeatureVersion");

                return this;
            }
        }

        public Criteria andProductFeatureVersionNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureVersionNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                    " not in", values, "productFeatureVersion");

                return this;
            }
        }

        public Criteria andProductFeatureVersionIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                    " in", Arrays.asList(values), "productFeatureVersion");

                return this;
            }
        }

        public Criteria andProductFeatureVersionNotIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                    " not in", Arrays.asList(values), "productFeatureVersion");

                return this;
            }
        }

        public Criteria andProductFeatureVersionIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " between", value1, value2, "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersion +
                " not between", value1, value2, "productFeatureVersion");

            return this;
        }

        public Criteria andProductFeatureVersionTypeIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " is null");

            return this;
        }

        public Criteria andProductFeatureVersionTypeIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " is not null");

            return this;
        }

        public Criteria andProductFeatureVersionTypeIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " <> ''");

            return this;
        }

        public Criteria andProductFeatureVersionTypeIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " = '')");

            return this;
        }

        public Criteria andProductFeatureVersionTypeEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " = ", value, "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionTypeEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionTypeNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " <>", value, "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " <>", value, "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionTypeNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionTypeGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " >", value, "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionTypeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionTypeGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " >=", value, "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionTypeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionTypeLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " <", value, "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionTypeLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionTypeLessThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " <=", value, "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionTypeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionTypeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " like", buffer.toString(), "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " not like", buffer.toString(), "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureVersionTypeEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                    " in", values, "productFeatureVersionType");

                return this;
            }
        }

        public Criteria andProductFeatureVersionTypeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureVersionTypeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                    " not in", values, "productFeatureVersionType");

                return this;
            }
        }

        public Criteria andProductFeatureVersionTypeIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionTypeEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                    " in", Arrays.asList(values), "productFeatureVersionType");

                return this;
            }
        }

        public Criteria andProductFeatureVersionTypeNotIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionTypeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                    " not in", Arrays.asList(values),
                    "productFeatureVersionType");

                return this;
            }
        }

        public Criteria andProductFeatureVersionTypeIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionTypeNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionTypeBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " between", value1, value2, "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionTypeNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionType +
                " not between", value1, value2, "productFeatureVersionType");

            return this;
        }

        public Criteria andProductFeatureVersionStatusIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " is null");

            return this;
        }

        public Criteria andProductFeatureVersionStatusIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " is not null");

            return this;
        }

        public Criteria andProductFeatureVersionStatusIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " <> ''");

            return this;
        }

        public Criteria andProductFeatureVersionStatusIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " = '')");

            return this;
        }

        public Criteria andProductFeatureVersionStatusEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " = ", value, "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionStatusEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionStatusNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " <>", value, "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " <>", value, "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionStatusNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionStatusGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " >", value, "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionStatusGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionStatusGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " >=", value, "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionStatusLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " <", value, "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionStatusLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionStatusLessThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " <=", value, "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureVersionStatusLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " like", buffer.toString(), "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " not like", buffer.toString(), "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureVersionStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                    " in", values, "productFeatureVersionStatus");

                return this;
            }
        }

        public Criteria andProductFeatureVersionStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureVersionStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                    " not in", values, "productFeatureVersionStatus");

                return this;
            }
        }

        public Criteria andProductFeatureVersionStatusIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                    " in", Arrays.asList(values), "productFeatureVersionStatus");

                return this;
            }
        }

        public Criteria andProductFeatureVersionStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureVersionStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                    " not in", Arrays.asList(values),
                    "productFeatureVersionStatus");

                return this;
            }
        }

        public Criteria andProductFeatureVersionStatusIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionStatusNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureVersionStatusBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " between", value1, value2, "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductFeatureVersionStatusNotBetween(
            String value1, String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureVersionStatus +
                " not between", value1, value2, "productFeatureVersionStatus");

            return this;
        }

        public Criteria andProductRequirementCodeIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " is null");

            return this;
        }

        public Criteria andProductRequirementCodeIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementCodeIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementCodeIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementCodeEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " = ", value, "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementCode);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementCodeEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementCodeNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " <>", value, "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " <>", value, "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementCode);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementCodeNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementCodeGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " >", value, "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementCode);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementCodeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementCodeGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " >=", value, "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementCode);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementCodeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementCodeLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " <", value, "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementCode);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementCodeLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementCodeLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " <=", value, "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementCode);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementCodeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementCodeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " like", buffer.toString(), "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " not like", buffer.toString(), "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementCodeEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                    " in", values, "productRequirementCode");

                return this;
            }
        }

        public Criteria andProductRequirementCodeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementCodeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                    " not in", values, "productRequirementCode");

                return this;
            }
        }

        public Criteria andProductRequirementCodeIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementCodeEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                    " in", Arrays.asList(values), "productRequirementCode");

                return this;
            }
        }

        public Criteria andProductRequirementCodeNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementCodeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                    " not in", Arrays.asList(values), "productRequirementCode");

                return this;
            }
        }

        public Criteria andProductRequirementCodeIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementCodeNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementCodeBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " between", value1, value2, "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementCodeNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementCode +
                " not between", value1, value2, "productRequirementCode");

            return this;
        }

        public Criteria andProductRequirementNameIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " is null");

            return this;
        }

        public Criteria andProductRequirementNameIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementNameIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementNameIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementNameEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " = ", value, "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementNameEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementNameNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " <>", value, "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " <>", value, "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementNameNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementNameGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " >", value, "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementNameGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementNameGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " >=", value, "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementNameLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " <", value, "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementNameLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementNameLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " <=", value, "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " like", buffer.toString(), "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " not like", buffer.toString(), "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                    " in", values, "productRequirementName");

                return this;
            }
        }

        public Criteria andProductRequirementNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                    " not in", values, "productRequirementName");

                return this;
            }
        }

        public Criteria andProductRequirementNameIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementNameEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                    " in", Arrays.asList(values), "productRequirementName");

                return this;
            }
        }

        public Criteria andProductRequirementNameNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                    " not in", Arrays.asList(values), "productRequirementName");

                return this;
            }
        }

        public Criteria andProductRequirementNameIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementNameNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementNameBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " between", value1, value2, "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementNameNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementName +
                " not between", value1, value2, "productRequirementName");

            return this;
        }

        public Criteria andProductRequirementContentIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " is null");

            return this;
        }

        public Criteria andProductRequirementContentIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementContentIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementContentIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementContentEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " = ", value, "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementContent);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementContentEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementContentNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " <>", value, "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " <>", value, "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementContent);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementContentNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementContentGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " >", value, "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementContent);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementContentGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementContentGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " >=", value, "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementContent);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementContentGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementContentLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " <", value, "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementContent);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementContentLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementContentLessThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " <=", value, "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementContent);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementContentLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementContentLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " like", buffer.toString(), "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " not like", buffer.toString(), "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementContentEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                    " in", values, "productRequirementContent");

                return this;
            }
        }

        public Criteria andProductRequirementContentNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementContentNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                    " not in", values, "productRequirementContent");

                return this;
            }
        }

        public Criteria andProductRequirementContentIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementContentEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                    " in", Arrays.asList(values), "productRequirementContent");

                return this;
            }
        }

        public Criteria andProductRequirementContentNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementContentNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                    " not in", Arrays.asList(values),
                    "productRequirementContent");

                return this;
            }
        }

        public Criteria andProductRequirementContentIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementContentNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementContentBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " between", value1, value2, "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementContentNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementContent +
                " not between", value1, value2, "productRequirementContent");

            return this;
        }

        public Criteria andProductRequirementTypeIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " is null");

            return this;
        }

        public Criteria andProductRequirementTypeIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementTypeIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementTypeIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementTypeEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " = ", value, "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementType);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementTypeEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementTypeNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " <>", value, "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " <>", value, "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementType);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementTypeNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementTypeGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " >", value, "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementType);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementTypeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementTypeGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " >=", value, "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementType);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementTypeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementTypeLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " <", value, "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementType);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementTypeLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementTypeLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " <=", value, "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementType);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementTypeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementTypeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " like", buffer.toString(), "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " not like", buffer.toString(), "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementTypeEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                    " in", values, "productRequirementType");

                return this;
            }
        }

        public Criteria andProductRequirementTypeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementTypeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                    " not in", values, "productRequirementType");

                return this;
            }
        }

        public Criteria andProductRequirementTypeIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementTypeEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                    " in", Arrays.asList(values), "productRequirementType");

                return this;
            }
        }

        public Criteria andProductRequirementTypeNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementTypeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                    " not in", Arrays.asList(values), "productRequirementType");

                return this;
            }
        }

        public Criteria andProductRequirementTypeIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementTypeNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementTypeBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " between", value1, value2, "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementTypeNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementType +
                " not between", value1, value2, "productRequirementType");

            return this;
        }

        public Criteria andProductRequirementLevelIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " is null");

            return this;
        }

        public Criteria andProductRequirementLevelIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementLevelIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementLevelIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementLevelEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " = ", value, "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementLevel);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementLevelEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementLevelNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " <>", value, "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " <>", value, "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementLevel);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementLevelNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementLevelGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " >", value, "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementLevel);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementLevelGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementLevelGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " >=", value, "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementLevel);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementLevelGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementLevelLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " <", value, "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementLevel);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementLevelLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementLevelLessThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " <=", value, "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementLevel);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementLevelLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementLevelLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " like", buffer.toString(), "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " not like", buffer.toString(), "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementLevelEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                    " in", values, "productRequirementLevel");

                return this;
            }
        }

        public Criteria andProductRequirementLevelNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementLevelNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                    " not in", values, "productRequirementLevel");

                return this;
            }
        }

        public Criteria andProductRequirementLevelIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementLevelEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                    " in", Arrays.asList(values), "productRequirementLevel");

                return this;
            }
        }

        public Criteria andProductRequirementLevelNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementLevelNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                    " not in", Arrays.asList(values), "productRequirementLevel");

                return this;
            }
        }

        public Criteria andProductRequirementLevelIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementLevelNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementLevelBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " between", value1, value2, "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementLevelNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementLevel +
                " not between", value1, value2, "productRequirementLevel");

            return this;
        }

        public Criteria andProductRequirementKindIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " is null");

            return this;
        }

        public Criteria andProductRequirementKindIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementKindIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementKindIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementKindEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " = ", value, "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementKind);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementKindEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementKindNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " <>", value, "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " <>", value, "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementKind);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementKindNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementKindGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " >", value, "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementKind);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementKindGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementKindGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " >=", value, "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementKind);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementKindGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementKindLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " <", value, "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementKind);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementKindLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementKindLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " <=", value, "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementKind);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementKindLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementKindLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " like", buffer.toString(), "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " not like", buffer.toString(), "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementKindEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                    " in", values, "productRequirementKind");

                return this;
            }
        }

        public Criteria andProductRequirementKindNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementKindNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                    " not in", values, "productRequirementKind");

                return this;
            }
        }

        public Criteria andProductRequirementKindIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementKindEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                    " in", Arrays.asList(values), "productRequirementKind");

                return this;
            }
        }

        public Criteria andProductRequirementKindNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementKindNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                    " not in", Arrays.asList(values), "productRequirementKind");

                return this;
            }
        }

        public Criteria andProductRequirementKindIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementKindNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementKindBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " between", value1, value2, "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementKindNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementKind +
                " not between", value1, value2, "productRequirementKind");

            return this;
        }

        public Criteria andProductRequirementSourceIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " is null");

            return this;
        }

        public Criteria andProductRequirementSourceIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " is not null");

            return this;
        }

        public Criteria andProductRequirementSourceIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " <> ''");

            return this;
        }

        public Criteria andProductRequirementSourceIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " = '')");

            return this;
        }

        public Criteria andProductRequirementSourceEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " = ", value, "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementSource);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementSourceEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementSourceNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " <>", value, "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " <>", value, "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementSource);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementSourceNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementSourceGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " >", value, "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementSource);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementSourceGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementSourceGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " >=", value, "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementSource);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementSourceGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementSourceLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " <", value, "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementSource);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementSourceLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementSourceLessThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " <=", value, "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductRequirementSource);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductRequirementSourceLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementSourceLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " like", buffer.toString(), "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " not like", buffer.toString(), "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementSourceEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                    " in", values, "productRequirementSource");

                return this;
            }
        }

        public Criteria andProductRequirementSourceNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductRequirementSourceNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                    " not in", values, "productRequirementSource");

                return this;
            }
        }

        public Criteria andProductRequirementSourceIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementSourceEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                    " in", Arrays.asList(values), "productRequirementSource");

                return this;
            }
        }

        public Criteria andProductRequirementSourceNotIn(String[] values) {
            if (values.length == 1) {
                return andProductRequirementSourceNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                    " not in", Arrays.asList(values), "productRequirementSource");

                return this;
            }
        }

        public Criteria andProductRequirementSourceIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementSourceNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductRequirementSourceBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " between", value1, value2, "productRequirementSource");

            return this;
        }

        public Criteria andProductRequirementSourceNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductRequirementSource +
                " not between", value1, value2, "productRequirementSource");

            return this;
        }

        public Criteria andProductFeatureCodeIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " is null");

            return this;
        }

        public Criteria andProductFeatureCodeIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " is not null");

            return this;
        }

        public Criteria andProductFeatureCodeIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " <> ''");

            return this;
        }

        public Criteria andProductFeatureCodeIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " = '')");

            return this;
        }

        public Criteria andProductFeatureCodeEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " = ", value, "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCode);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCodeEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCodeNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " <>", value, "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeNotEqualToOrIsNull(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureCode + " <>",
                value, "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCode);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCodeNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCodeGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " >", value, "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCode);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCodeGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCodeGreaterThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " >=", value, "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCode);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCodeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCodeLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " <", value, "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCode);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCodeLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCodeLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " <=", value, "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCode);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCodeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCodeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " like", buffer.toString(), "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " not like", buffer.toString(), "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureCodeEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                    " in", values, "productFeatureCode");

                return this;
            }
        }

        public Criteria andProductFeatureCodeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureCodeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                    " not in", values, "productFeatureCode");

                return this;
            }
        }

        public Criteria andProductFeatureCodeIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureCodeEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                    " in", Arrays.asList(values), "productFeatureCode");

                return this;
            }
        }

        public Criteria andProductFeatureCodeNotIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureCodeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                    " not in", Arrays.asList(values), "productFeatureCode");

                return this;
            }
        }

        public Criteria andProductFeatureCodeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCodeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCodeBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " between", value1, value2, "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureCodeNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCode +
                " not between", value1, value2, "productFeatureCode");

            return this;
        }

        public Criteria andProductFeatureNameIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " is null");

            return this;
        }

        public Criteria andProductFeatureNameIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " is not null");

            return this;
        }

        public Criteria andProductFeatureNameIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " <> ''");

            return this;
        }

        public Criteria andProductFeatureNameIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " = '')");

            return this;
        }

        public Criteria andProductFeatureNameEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " = ", value, "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureNameEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureNameNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " <>", value, "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureName + " <>",
                value, "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureNameNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureNameGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " >", value, "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureNameGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " >=", value, "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureNameLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " <", value, "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureNameLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureNameLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " <=", value, "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " like", buffer.toString(), "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " not like", buffer.toString(), "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                    " in", values, "productFeatureName");

                return this;
            }
        }

        public Criteria andProductFeatureNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                    " not in", values, "productFeatureName");

                return this;
            }
        }

        public Criteria andProductFeatureNameIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureNameEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                    " in", Arrays.asList(values), "productFeatureName");

                return this;
            }
        }

        public Criteria andProductFeatureNameNotIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                    " not in", Arrays.asList(values), "productFeatureName");

                return this;
            }
        }

        public Criteria andProductFeatureNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureNameBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " between", value1, value2, "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureNameNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureName +
                " not between", value1, value2, "productFeatureName");

            return this;
        }

        public Criteria andProductFeatureCanTestIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " is null");

            return this;
        }

        public Criteria andProductFeatureCanTestIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " is not null");

            return this;
        }

        public Criteria andProductFeatureCanTestIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " <> ''");

            return this;
        }

        public Criteria andProductFeatureCanTestIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " = '')");

            return this;
        }

        public Criteria andProductFeatureCanTestEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " = ", value, "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCanTestEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCanTestNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " <>", value, "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestNotEqualToOrIsNull(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " <>", value, "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCanTestNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCanTestGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " >", value, "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCanTestGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCanTestGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " >=", value, "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCanTestGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCanTestLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " <", value, "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCanTestLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCanTestLessThanOrEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " <=", value, "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureCanTestLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCanTestLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " like", buffer.toString(), "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " not like", buffer.toString(), "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureCanTestEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                    " in", values, "productFeatureCanTest");

                return this;
            }
        }

        public Criteria andProductFeatureCanTestNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureCanTestNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                    " not in", values, "productFeatureCanTest");

                return this;
            }
        }

        public Criteria andProductFeatureCanTestIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureCanTestEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                    " in", Arrays.asList(values), "productFeatureCanTest");

                return this;
            }
        }

        public Criteria andProductFeatureCanTestNotIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureCanTestNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                    " not in", Arrays.asList(values), "productFeatureCanTest");

                return this;
            }
        }

        public Criteria andProductFeatureCanTestIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCanTestNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureCanTestBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " between", value1, value2, "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureCanTestNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureCanTest +
                " not between", value1, value2, "productFeatureCanTest");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureIsNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " is null");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureIsNotNull() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " is not null");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureIsNotEmpty() {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " is not null AND " +
                IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " <> ''");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureIsEmpty() {
            addCriterion("(" +
                IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " = '')");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " = ", value, "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureNotEqualTo(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " <>", value, "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureNotEqualToOrIsNull(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " is null OR " +
                IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " <>", value, "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureGreaterThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " >", value, "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureGreaterThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " >=", value, "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureLessThan(String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " <", value, "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureLessThanOrEqualTo(
            String value) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " <=", value, "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " like", buffer.toString(), "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " not like", buffer.toString(), "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureIsKeyFeatureEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                    " in", values, "productFeatureIsKeyFeature");

                return this;
            }
        }

        public Criteria andProductFeatureIsKeyFeatureNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductFeatureIsKeyFeatureNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                    " not in", values, "productFeatureIsKeyFeature");

                return this;
            }
        }

        public Criteria andProductFeatureIsKeyFeatureIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureIsKeyFeatureEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                    " in", Arrays.asList(values), "productFeatureIsKeyFeature");

                return this;
            }
        }

        public Criteria andProductFeatureIsKeyFeatureNotIn(String[] values) {
            if (values.length == 1) {
                return andProductFeatureIsKeyFeatureNotEqualTo(values[0]);
            } else {
                addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                    " not in", Arrays.asList(values),
                    "productFeatureIsKeyFeature");

                return this;
            }
        }

        public Criteria andProductFeatureIsKeyFeatureIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " between", value1, value2, "productFeatureIsKeyFeature");

            return this;
        }

        public Criteria andProductFeatureIsKeyFeatureNotBetween(String value1,
            String value2) {
            addCriterion(IProductRequirementFeatureRelateDAO.ProductFeatureIsKeyFeature +
                " not between", value1, value2, "productFeatureIsKeyFeature");

            return this;
        }
    }
}
